Exercise: Python Grundlagen

📚 Zusammenfassung – Python Grundlagen

Variablen: Dynamische Typisierung – kein Typ nötig: x = 5
Sequenzen: list (veränderlich), tuple (unveränderlich), range, str
Slicing: s[start:stop:step] – negativer step geht rückwärts
range: range(start, stop, step)
Listenoperationen: append, del, remove, reverse, sort, len, sum, max, min
Exceptions: try / except / finally

Teil 1: Variablen & Typen

x = 42
y = 3.14
s = "ETH"
b = True

Ausdruck	Ergebnis / Typ
`type(x)`
`type(y)`
`type(s)`
`type(b)`
`x + 8`
`x ** 2`
`x and b`

💡 Hinweis: In Python liefert type() den Typ einer Variable. Der **-Operator berechnet Potenzen: 42² = 1764.

Teil 2: Listenoperationen

l = [3, 1, 4, 1, 5, 9, 2, 6]

Ausdruck	Ergebnis
`len(l)`
`sum(l)`
`max(l)`
`min(l)`
`l.count(1)`
`l.index(5)`
`4 in l`
`7 in l`

💡 Hinweis: len zählt Elemente, count(val) zählt Vorkommen eines Werts, index(val) gibt den ersten Index zurück (0-basiert).

Teil 3: Liste Schritt für Schritt verändern

l = [0] * 4

Wie sieht l nach jedem Schritt aus? (Listennotation, z.B. [1, 2, 3])

Befehl	l danach
`l = [0] * 4`
`l[2] = 7`
`l.append(3)`
`l.reverse()`
`del l[1]`
`l.remove(0)`

💡 Hinweis: del l[i] entfernt das Element am Index i. remove(val) entfernt das erste Vorkommen von val. reverse() kehrt die Reihenfolge in-place um.

Teil 4: Slicing

s = [1, 3, 6, 7, 9, 3, 5, 0, 2]

Ausdruck	Ergebnis
`s[2:5]`
`s[1:7:2]`
`s[8:4:-1]`
`s[-3:]`
`s[::3]`

💡 Hinweis: s[start:stop:step] – stop ist exklusiv! Negativer step geht rückwärts. Negative Indizes zählen vom Ende: s[-3] ist das drittletzte Element.

Teil 5: range & tuple

Ausdruck	Ergebnis
`tuple(range(3, 15, 4))`
`tuple(range(10, 0, -3))`
`list(range(5))`

💡 Hinweis: range(start, stop, step) endet vor stop.

x, y = 1, 2
x, y = y, x

Ausdruck	Ergebnis
`print(x)`
`print(y)`

💡 Hinweis: Tuple-Swap x, y = y, x tauscht zwei Variablen ohne Hilfsvariable.

Teil 6: Exceptions

a = [1, 2, 3]
try:
    print(a[0]/a[1])
    print(a[5])
    print("Ende try")
except IndexError:
    print("IndexError!")
except ZeroDivisionError:
    print("ZeroDivisionError!")
finally:
    print("Fertig.")

Ausgabezeile	Wert
1. Zeile
2. Zeile
3. Zeile

💡 Hinweis: Sobald eine Exception ausgelöst wird, springt Python sofort in den passenden except-Block – der restliche try-Code wird übersprungen. finally wird immer ausgeführt.